home *** CD-ROM | disk | FTP | other *** search
/ InfoMagic Internet Tools 1993 July / Internet Tools.iso / RockRidge / mail / pp / pp-6.0 / Chans / x40084 / P1_out.py < prev    next >
Encoding:
Text File  |  1991-12-18  |  24.4 KB  |  1,113 lines
  1. -- P1: P1 MHS definitions
  2.  
  3.  
  4. -- @(#) $Header: /xtel/pp/pp-beta/Chans/x40084/RCS/P1_out.py,v 6.0 1991/12/18 20:13:50 jpo Rel $
  5. --
  6. -- $Log: P1_out.py,v $
  7. -- Revision 6.0  1991/12/18  20:13:50  jpo
  8. -- Release 6.0
  9. --
  10. --
  11. --
  12.  
  13.  
  14. P1 DEFINITIONS ::=
  15.  
  16. %{
  17. #ifndef lint
  18. static char Rcsid [] = "@(#)$Header";
  19. #endif  lint
  20.  
  21. #include "head.h"
  22. #include "q.h"
  23. #include "or.h"
  24. #include "dr.h"
  25. #include "rtsparams.h" 
  26. #include <isode/cmd_srch.h>
  27.  
  28.  
  29. #define PPSTRUCT        "/usr/pp/pp/logs/x400out84.pdus"
  30.  
  31.  
  32. extern char                 *body_string;
  33. extern char                 *cont_p2;
  34. extern int            trace_type;
  35. extern int                  body_len;
  36. extern Q_struct            *PPQuePtr;
  37. extern DRmpdu            *DRptr;
  38. extern ADDR            *ad_list;
  39.  
  40.  
  41. static int            aninteger;
  42. struct botheit {
  43.         EncodedIT       *eit;
  44.         LIST_BPT        *bp;
  45. };
  46.  
  47.  
  48.  
  49. /* -- local routines -- */
  50. int                testdebug();
  51. static int            get_content_type();
  52. static int            or_print_struct();
  53. static int            pmf2int();
  54. static int            same_trace();
  55. static void            compress_trace();
  56. static void            compress_trace_admd_style();
  57. static void            compress_trace_localinternal_style();
  58. static void            convert2printablestring();
  59.  
  60.  
  61.  
  62.  
  63. /* ----------------------  Begin Routines ----------------------------------- */
  64.  
  65.  
  66.  
  67.  
  68.  
  69. #ifdef  DEBUG
  70. int     testdebug (pe, s)
  71. register PE     pe;
  72. register char   *s;
  73. {
  74.     register PS ps;
  75.     static int debug = OK;
  76.     static FILE *fptrace;
  77.  
  78.     switch (debug) {
  79.         case NOTOK:
  80.             return;
  81.  
  82.         case OK:
  83.             if ((pp_log_norm -> ll_events & LLOG_PDUS) == 0) {
  84.                 debug = NOTOK;
  85.                 break;
  86.             }
  87.             debug = 1;
  88.             fflush (stdout);
  89.             if (access (PPSTRUCT, 02) == NOTOK) {
  90.                 debug = NOTOK;
  91.                 break;
  92.             }
  93.  
  94.             fptrace = fopen (PPSTRUCT, "a");
  95.             if (fptrace == NULL) {
  96.                 debug = NOTOK;
  97.                 break;
  98.             }
  99.             fprintf (fptrace, "testdebug made with %s\n", pepyid);
  100.             /* and fall... */
  101.  
  102.         default:
  103.             fflush (stdout);
  104.             fprintf (fptrace, "%s\n", s);
  105.  
  106.             if ((ps = ps_alloc (std_open)) == NULLPS)
  107.                 break;
  108.             if (std_setup (ps, fptrace) != NOTOK)
  109.                 (void) pe2pl (ps, pe);
  110.             fprintf (fptrace, "--------\n");
  111.             (void) fflush (fptrace);
  112.             ps_free (ps);
  113.             break;
  114.     }
  115. }
  116.  
  117. #endif  /* DEBUG */
  118.  
  119. %}
  120.  
  121.  
  122.  
  123.  
  124. BEGIN
  125.  
  126. ENCODER build
  127.  
  128.  
  129. -- P1 makes use of types defined in the following module:
  130. -- Sa: Recommendation S.a [14]
  131. -- T73: T.73, Section 5
  132.  
  133. MPDU ::=
  134.         CHOICE << PPQuePtr->msgtype == MT_UMPDU ? 1 : 2 >> {
  135.             [0]
  136.                 IMPLICIT UserMPDU [[p PPQuePtr]],
  137.  
  138.                 -- service mpdus are sent as ordinary messages
  139.  
  140.                 ServiceMPDU [[p PPQuePtr]]
  141.         }
  142.  
  143.  
  144.  
  145. ServiceMPDU [[P Q_struct *]] ::=
  146.         CHOICE << parm->msgtype == MT_DMPDU ? 1 : 2 >> {
  147.             [1]
  148.                 IMPLICIT DeliveryReportMPDU [[p parm]],
  149.  
  150.             [2]
  151.                 IMPLICIT ProbeMPDU [[p parm]]
  152.         }
  153.  
  154.  
  155.  
  156. UserMPDU [[P Q_struct *]] ::=
  157.         SEQUENCE {
  158.             envelope
  159.                 UMPDUEnvelope [[p parm]],
  160.  
  161.             content
  162.                 UMPDUContent [[o body_string $ body_len]]
  163.         }
  164.  
  165.  
  166.  
  167.  
  168. UMPDUEnvelope [[P Q_struct *]]
  169.         %{
  170.                 char            *cp;
  171.                 ADDR            *ap;
  172.                 struct botheit  b;
  173.         %} ::=
  174.         SET {
  175.             mpduID
  176.                 MPDUIdentifier [[p &parm->msgid]],
  177.  
  178.             originator %{
  179.                 cp = parm->Oaddress->ad_r400adr;
  180.                 if (cp == NULLCP)
  181.                         cp = parm->Oaddress->ad_value;
  182.                 %}
  183.                 ORName [[p cp]],
  184.  
  185.  
  186.             original %{
  187.                 b.eit = &parm->orig_encodedinfo;
  188.                 b.bp = ad_list -> ad_eit;
  189.                 %} EncodedInformationTypes [[p &b]],
  190.  
  191.  
  192.             ContentType [[i get_content_type (ad_list, parm)]],
  193.  
  194.             UAContentId [[p parm->ua_id]] OPTIONAL
  195.                         <<parm->ua_id != NULLCP >>,
  196.  
  197.             Priority [[i parm->priority]] DEFAULT normal 
  198.             <<parm->priority != 0 >>,
  199.  
  200.             PerMessageFlag [[p parm]]
  201.             DEFAULT {} <<parm-> disclose_recips ||
  202.                 parm -> implicit_conversion_prohibited ||
  203.                 parm -> alternate_recip_allowed ||
  204.                 parm -> content_return_request >>,
  205.  
  206.             deferredDelivery [0]
  207.                 IMPLICIT Time
  208.                         [[p parm->defertime]] OPTIONAL
  209.                         <<parm->defertime != NULLUTC>>,
  210.  
  211.             [1]
  212.                 IMPLICIT SEQUENCE OF
  213.                         PerDomainBilateralInfo OPTIONAL,
  214.  
  215.             [2]
  216.                 IMPLICIT SEQUENCE OF
  217.                         <<ap=parm->Raddress; ap!=NULLADDR; ap=ap->ad_next>>
  218.                         RecipientInfo [[p ap]],
  219.  
  220.             TraceInformation [[p &parm->trace]]
  221.  
  222.         }
  223.  
  224.  
  225.  
  226. UMPDUContent ::=
  227.         OCTETSTRING [[o body_string $ body_len]]
  228.  
  229.  
  230.  
  231. -- time
  232.  
  233. Time [[P UTC]]
  234.         %{
  235.                 char *str;
  236.         %} ::=
  237.         %{ str= utct2str (parm); %}
  238.         UniversalTime [[s str]]
  239.  
  240.  
  241.  
  242. -- various envelope information
  243.  
  244. MPDUIdentifier [[P MPDUid *]]
  245.         %{
  246.                 char tbuf[LINESIZE];
  247.         %} ::=
  248.         [APPLICATION 4] IMPLICIT SEQUENCE {
  249.             GlobalDomainIdentifier
  250.                 [[p &parm->mpduid_DomId]],
  251.  
  252.         dummy %{
  253.         bzero (tbuf, LINESIZE);        
  254.             strncpy (tbuf, parm -> mpduid_string, 32);
  255.         %}
  256.             IA5String [[s tbuf]]
  257.         }
  258.  
  259.  
  260.  
  261. ContentType ::=
  262.         [APPLICATION 6]
  263.             IMPLICIT INTEGER {
  264.                 p2 (2)
  265.             }
  266.  
  267.  
  268.  
  269. UAContentId [[P char *]]
  270.         %{
  271.                 char tbuf[LINESIZE];
  272.         %} ::=
  273.         %{
  274.         bzero (tbuf, LINESIZE);        
  275.                 strncpy (tbuf, parm, 16);
  276.         %}
  277.         [APPLICATION 10]
  278.             IMPLICIT PrintableString [[s tbuf]]
  279.  
  280.  
  281. Priority ::=
  282.         [APPLICATION 7]
  283.             IMPLICIT INTEGER {
  284.                 normal (0),
  285.                 nonUrgent (1),
  286.                 urgent (2)
  287.             }
  288.  
  289.  
  290.  
  291. PerMessageFlag [[P Q_struct *]] ::=
  292.         [APPLICATION 8] 
  293.             IMPLICIT BITSTRING [[x int2strb(pmf2int(parm),4) $ 4 ]] {
  294.                 discloseRecipients (0),
  295.                 conversionProhibited (1),
  296.                 alternateRecipientAllowed (2),
  297.                 contentReturnRequest (3)
  298.             } 
  299.  
  300.  
  301.  
  302. -- per-domain bilateral information
  303.  
  304. PerDomainBilateralInfo ::=
  305.         SEQUENCE {
  306.             country
  307.                 CountryName,
  308.                 AdministrationDomainName,
  309.                 BilateralInfo
  310.         }
  311.  
  312.  
  313.  
  314. BilateralInfo ::=
  315.         ANY
  316.  
  317.  
  318.  
  319. -- recipient information
  320.  
  321. RecipientInfo [[P ADDR *]]
  322.         %{
  323.                 char            *cp;
  324.         %} ::=
  325.         SET {
  326.             recipient %{
  327.                 cp = parm->ad_r400adr;
  328.                 if (cp == NULLCP)
  329.                         cp = parm->ad_value;
  330.                 %}
  331.                 ORName [[p cp]],
  332.  
  333.             [0]
  334.                 IMPLICIT ExtensionIdentifier [[i parm->ad_extension]],
  335.  
  336.             [1]
  337.                 %{
  338.             int    resp;
  339.             ADDR    *ap;
  340.             for (ap = ad_list; ap; ap = ap -> ad_next)
  341.                 if (ap -> ad_no == parm -> ad_no)
  342.                     break;
  343.             if (ap == NULLADDR)
  344.                 resp = FALSE;
  345.             else    resp = parm -> ad_resp;
  346.                         aninteger = mem2prf (resp, parm->ad_mtarreq,
  347.                                         parm->ad_usrreq);
  348.                 %}
  349.                 IMPLICIT PerRecipientFlag [[x int2strb (aninteger, 8) $ 8 ]],
  350.  
  351.             [2]
  352.                 IMPLICIT ExplicitConversion
  353.                         [[i parm->ad_explicitconversion]] DEFAULT {}
  354.         }
  355.  
  356.  
  357.  
  358. ExtensionIdentifier ::=
  359.         INTEGER
  360.  
  361.  
  362. PerRecipientFlag ::=
  363.         BITSTRING -- See Figure 23/X.411
  364.  
  365.  
  366. ExplicitConversion ::=
  367.         INTEGER {
  368.             iA5TextTeletex (0),
  369.             teletexTelex (1)
  370.         }
  371.  
  372.  
  373.  
  374. -- trace information
  375.  
  376. TraceInformation [[P Trace **]]
  377.         %{
  378.                 Trace   *tp;
  379.         %} ::=
  380.  
  381.  
  382.     %{
  383.         compress_trace (parm);
  384.     %}
  385.  
  386.  
  387.         [APPLICATION 9]
  388.             IMPLICIT SEQUENCE OF
  389.                 <<tp = *parm; tp; tp = tp->trace_next>>
  390.                         SEQUENCE {
  391.                                 domainid
  392.                                         GlobalDomainIdentifier
  393.                                                 [[p &tp->trace_DomId]],
  394.                                 domaininfo
  395.                                         DomainSuppliedInfo
  396.                                                 [[p &tp->trace_DomSinfo]]
  397.             }
  398.  
  399.  
  400.  
  401. DomainSuppliedInfo [[P DomSupInfo *]]
  402.         %{
  403.                 struct botheit b;
  404.         %} ::=
  405.         SET {
  406.             arrival [0] %{
  407.         if (parm -> dsi_time == NULL)
  408.             parm->dsi_time = utcnow ();
  409.         %}
  410.                 IMPLICIT Time [[p parm->dsi_time]],
  411.  
  412.             deferred [1]
  413.                 IMPLICIT Time [[p parm->dsi_deferred]] OPTIONAL
  414.                         <<parm->dsi_deferred != NULLUTC>>,
  415.  
  416.             action [2]
  417.                 IMPLICIT INTEGER [[i parm->dsi_action]] {
  418.                     relayed (0),
  419.                     rerouted (1)
  420.                 },
  421.  
  422.             converted %{
  423.                 b.eit = &parm->dsi_converted;
  424.                 b.bp = NULL;
  425.             %} EncodedInformationTypes
  426.                     [[p &b]] OPTIONAL
  427.                         <<parm->dsi_converted.eit_types != 0>>,
  428.  
  429.             previous
  430.                 GlobalDomainIdentifier
  431.                     [[p &parm->dsi_attempted_md]] OPTIONAL
  432.                         <<parm->dsi_attempted_md.global_Country != NULLCP>>
  433.         }
  434.  
  435.  
  436.  
  437. -- global domain identifier
  438.  
  439. GlobalDomainIdentifier [[P GlobalDomId *]] ::=
  440.         [APPLICATION 3]
  441.             IMPLICIT SEQUENCE {
  442.                 CountryName [[p parm->global_Country]],
  443.                 AdministrationDomainName [[p parm->global_Admin]],
  444.                 PrivateDomainIdentifier [[p parm->global_Private]] OPTIONAL
  445.                         <<parm->global_Private != NULLCP>>
  446.             }
  447.  
  448.  
  449. CountryName [[P char *]] ::=
  450.         [APPLICATION 1]
  451.             CHOICE << (parm && or_str_isns(parm)) ? 1 : 2 >> {
  452.                 NumericString [[s parm ? parm : "" ]],
  453.                 PrintableString [[s parm ? parm : "" ]]
  454.             }
  455.  
  456.  
  457.  
  458. AdministrationDomainName [[P char *]] ::=
  459.         [APPLICATION 2]
  460.             CHOICE << (parm && or_str_isns(parm)) ? 1 : 2 >> {
  461.                 NumericString [[s parm ? parm : ""]],
  462.                 PrintableString [[s parm ? parm : ""]]
  463.             }
  464.  
  465.  
  466.  
  467. PrivateDomainIdentifier [[P char *]] ::=
  468.         CHOICE << (parm && or_str_isns(parm)) ? 1 : 2 >> {
  469.             NumericString [[s parm ? parm : ""]],
  470.             PrintableString [[s parm ? parm : ""]]
  471.         }
  472.  
  473.  
  474.  
  475.  
  476. -- O/R name
  477.  
  478. ORName [[P char *]]
  479.         %{
  480.                 OR_ptr  or;
  481.                 PE      peptr = NULLPE; 
  482.  
  483.                 or = or_std2or (parm);
  484.                 if (or == NULLOR) {
  485.                         advise (NULLCP, "x400out84: Bad ORName %s", parm);
  486.             return NOTOK;
  487.         }
  488.         or_downgrade(&or);
  489.                 or_print_struct (or, 0);
  490.  
  491.                 if (build_OR_ORName (&peptr, 1, 0, NULLCP, or) == NOTOK)
  492.                         if (peptr) {
  493.                                 pe_free (peptr);
  494.                                 peptr= NULLPE;
  495.                         }
  496.                 or_free (or);
  497.         {
  498.         %} ::=
  499.         ANY [[a peptr]]
  500.         %{
  501.         }
  502.         %}
  503.  
  504.  
  505.  
  506. -- encoded information types
  507.  
  508. EncodedInformationTypes [[P struct botheit *]] ::=
  509.         %{
  510.                 if (parm->bp)
  511.                         aninteger = mem2enctypes (parm->bp);
  512.                 else
  513.                         aninteger = mem2enctypes (parm->eit->eit_types);
  514.         %}
  515.  
  516.         [APPLICATION 5] IMPLICIT SET {
  517.             [0]
  518.                 IMPLICIT BITSTRING  [[x int2strb (aninteger, 10) $ 10]]
  519.                 {
  520.                         undefined(0),
  521.                         tLX(1),
  522.                         iA5Text(2),
  523.                         g3Fax(3),
  524.                         tIF0(4),
  525.                         tTX(5),
  526.                         videotex(6),
  527.                         voice(7),
  528.                         sFD(8),
  529.                         tIF1(9)
  530.                 },
  531.  
  532.  
  533.             [1]
  534.                 IMPLICIT G3NonBasicParams
  535.                         [[x int2strb (parm->eit->eit_g3parms, 30) $ 30]] OPTIONAL
  536.                                 <<list_bpt_find (parm->eit->eit_types,
  537.                                                 "P2.g3fax")>>,
  538.             [2]
  539.                 IMPLICIT TeletexNonBasicParams OPTIONAL,
  540.  
  541.             [3]
  542.                 IMPLICIT PresentationCapabilities OPTIONAL
  543.  
  544.         -- other non-basic parameters are for further study
  545.  
  546.         }
  547.  
  548.  
  549.  
  550. G3NonBasicParams ::=
  551.         BITSTRING {
  552.             twoDimensional(8),
  553.             fineResolution(9),
  554.             unlimitedLength(20),
  555.             b4Length(21),
  556.             a3Width(22),
  557.             b4Width(23),
  558.             uncompressed(30)
  559.         }
  560.  
  561.  
  562.  
  563. TeletexNonBasicParams ::=
  564.         SET {
  565.             graphicCharacterSets [0]
  566.                 IMPLICIT T61String OPTIONAL,
  567.  
  568.             controlCharacterSets [1]
  569.                 IMPLICIT T61String OPTIONAL,
  570.  
  571.             pageFormats [2]
  572.                 IMPLICIT OCTETSTRING OPTIONAL,
  573.  
  574.             miscTerminalCapabilities [3]
  575.                 IMPLICIT T61String OPTIONAL,
  576.  
  577.             privateUse [4]
  578.                 IMPLICIT OCTETSTRING OPTIONAL
  579.         }
  580.  
  581.  
  582.  
  583. PresentationCapabilities ::=
  584.         T73PresentationCapabilities
  585.  
  586.  
  587.  
  588. T73PresentationCapabilities ::=
  589.         SET { --unimportant-- }
  590.  
  591.  
  592.  
  593.  
  594. -- Delivery Report MPDU
  595.  
  596. DeliveryReportMPDU [[P Q_struct *]]::=
  597.         SEQUENCE {
  598.             envelope
  599.                 DeliveryReportEnvelope [[p parm]],
  600.  
  601.             content
  602.                 DeliveryReportContent [[p parm]]
  603.         }
  604.  
  605.  
  606.  
  607.  
  608. DeliveryReportEnvelope [[P Q_struct *]] ::=
  609.         SET {
  610.             report
  611.                 MPDUIdentifier [[p DRptr-> dr_mpduid]],
  612.  
  613.             originator
  614.                 ORName [[p parm->Oaddress->ad_r400adr]],
  615.  
  616.             TraceInformation [[p &DRptr->dr_trace]]
  617.         }
  618.  
  619.  
  620.  
  621. DeliveryReportContent [[P Q_struct *]]
  622.         %{
  623.                 Rrinfo   *rq;
  624.         %} ::=
  625.         SET {
  626.             original
  627.                 MPDUIdentifier [[p &parm->msgid]],
  628.  
  629.             intermediate
  630.                 TraceInformation [[p &DRptr-> dr_subject_intermediate_trace]]
  631.                 OPTIONAL << DRptr -> dr_subject_intermediate_trace>>,
  632.  
  633.             UAContentId [[p parm->ua_id]] OPTIONAL
  634.                         <<parm->ua_id != NULLCP>>,
  635.  
  636.             [0]
  637.                 IMPLICIT SEQUENCE OF
  638.                         <<rq = DRptr->dr_recip_list; rq;
  639.                           rq = rq->rr_next>>
  640.                 ReportedRecipientInfo [[p rq]],
  641.  
  642.             returned [1]
  643.                 IMPLICIT UMPDUContent [[o body_string $ body_len ]] OPTIONAL <<body_len != 0>>,
  644.  
  645.             billingInformation [2]
  646.                 ANY OPTIONAL
  647.         }
  648.  
  649.  
  650.  
  651. ReportedRecipientInfo [[P Rrinfo *]]
  652.         %{
  653.                 ADDR    *ap;
  654.         %} ::= %{
  655.                 for (ap = PPQuePtr -> Raddress; ap; ap = ap -> ad_next)
  656.                         if (ap -> ad_no == parm -> rr_recip)
  657.                                 break;
  658.                 if (ap == NULLADDR) {
  659.                         PP_OPER (NULLCP, ("NO match for recip %d terminating",
  660.                                           parm -> rr_recip));
  661.                         exit (3);
  662.                 }
  663.         %}
  664.         SET
  665.         {
  666.             recipient [0]
  667.                 IMPLICIT ORName [[p ap->ad_r400adr]] %{
  668.         $$ -> pe_class = PE_CLASS_CONT;
  669.         $$ -> pe_id = 0;
  670.         %},
  671.  
  672.             [1]
  673.                 IMPLICIT ExtensionIdentifier [[i ap->ad_extension]],
  674.  
  675.             [2]
  676.                 %{
  677.                         aninteger = mem2prf (ap->ad_resp,
  678.                                          ap->ad_mtarreq,
  679.                                          ap->ad_usrreq);
  680.                 %}
  681.                 IMPLICIT PerRecipientFlag [[x int2strb (aninteger, 8) $ 8 ]],
  682.  
  683.             [3] IMPLICIT LastTraceInformation [[p parm]],
  684.  
  685.             intendedRecipient [4]
  686.                 IMPLICIT 
  687.             ORName [[p parm->rr_originally_intended_recip->fn_addr]]
  688.                 %{
  689.                     $$ -> pe_class = PE_CLASS_CONT;
  690.                     $$ -> pe_id = 4;
  691.                 %} OPTIONAL
  692.                 <<parm->rr_originally_intended_recip &&
  693.                                parm->rr_originally_intended_recip->fn_addr>> ,
  694.  
  695.             [5]
  696.                 %{
  697.             convert2printablestring (parm -> rr_supplementary);
  698.         %} 
  699.                 IMPLICIT SupplementaryInformation
  700.                             [[o parm -> rr_supplementary $ 
  701.                             min ((int)strlen(parm->rr_supplementary), 64)]] 
  702.             OPTIONAL
  703.             <<parm->rr_supplementary != NULLCP>>
  704.         }
  705.  
  706.  
  707.  
  708. -- last trace information
  709.  
  710. LastTraceInformation [[P Rrinfo *]]
  711.         %{
  712.                 struct botheit b;
  713.         %} ::=
  714.         SET {
  715.             arrival [0]
  716.                 IMPLICIT Time [[p parm->rr_arrival]],
  717.  
  718.             converted %{
  719.                 b.eit = parm->rr_converted;
  720.                 b.bp = NULL;
  721.             %} EncodedInformationTypes [[p &b]] OPTIONAL
  722.                         <<parm->rr_converted != 0>>,
  723.  
  724.             [1]
  725.                 Report [[p &parm->rr_report]]
  726.         }
  727.  
  728.  
  729.  
  730. Report [[P Report *]] ::=
  731.         CHOICE <<parm->rep_type == DR_REP_SUCCESS ? 1 : 2 >> {
  732.             [0]
  733.                 IMPLICIT DeliveredInfo [[p &parm->rep.rep_dinfo]],
  734.  
  735.             [1]
  736.                 IMPLICIT NonDeliveredInfo [[p &parm->rep.rep_ndinfo]]
  737.         }
  738.  
  739.  
  740.  
  741. DeliveredInfo [[P Delinfo *]] ::=
  742.         SET {
  743.             delivery [0]
  744.                 IMPLICIT Time [[p parm->del_time]],
  745.  
  746.             typeOfUA [1]
  747.                 IMPLICIT INTEGER [[i parm->del_type]] {
  748.                     public (0),
  749.                     private (1)
  750.                 } DEFAULT public <<parm->del_type != 0>>
  751.         }
  752.  
  753.  
  754.  
  755. NonDeliveredInfo [[P NonDelinfo *]] ::=
  756.         SET {
  757.             [0]
  758.                 %{
  759.                         if (parm->nd_rcode > 2)
  760.                                 parm->nd_rcode = 0;
  761.                 %}
  762.                 IMPLICIT ReasonCode [[i parm->nd_rcode]],
  763.  
  764.             [1]
  765.                 %{
  766.                         if (parm->nd_dcode > 11)
  767.                                 parm->nd_dcode = 11;
  768.                 %}
  769.                 IMPLICIT DiagnosticCode [[i parm->nd_dcode]] OPTIONAL
  770.                         <<parm->nd_dcode >= 0>>
  771.         }
  772.  
  773.  
  774.  
  775. ReasonCode ::=
  776.         INTEGER {
  777.             transferFailure (0),
  778.  
  779.             unableToTransfer (1),
  780.  
  781.             conversionNotPerformed (2)
  782.  
  783.         }
  784.  
  785.  
  786.  
  787. DiagnosticCode  ::=
  788.         INTEGER {
  789.             unrecognizedORName (0),
  790.  
  791.             ambiguousORName (1),
  792.  
  793.             mtaCongestion (2),
  794.  
  795.             loopDetected (3),
  796.  
  797.             uaUnavailable (4),
  798.  
  799.             maximumTimeExpired (5),
  800.  
  801.             encodedInformationTypesUnsupported (6),
  802.  
  803.             contentTooLong (7),
  804.  
  805.             conversionImpractical (8),
  806.  
  807.             conversionProhibited (9),
  808.  
  809.             implicitConversionNotResgistered (10),
  810.  
  811.             invalidParameters (11)
  812.         }
  813.  
  814.  
  815.  
  816. -- supplementary information
  817.  
  818. SupplementaryInformation ::=
  819.         PrintableString -- length limited and for further study
  820.  
  821.  
  822.  
  823.  
  824. -- Probe MPDU
  825.  
  826. ProbeMPDU [[P Q_struct *]]::=
  827.         ProbeEnvelope [[p parm]]
  828.  
  829.  
  830.  
  831. ProbeEnvelope [[P Q_struct *]]
  832.         %{
  833.                 char    *cp;
  834.                 ADDR    *ap;
  835.                 struct botheit b;
  836.         %} ::=
  837.  
  838.         SET {
  839.             probe
  840.                 MPDUIdentifier [[p &parm->msgid]],
  841.  
  842.  
  843.             originator %{
  844.                 cp = parm->Oaddress->ad_r400adr;
  845.                 if (cp == NULLCP)
  846.                         cp = parm->Oaddress->ad_value;
  847.                 %}
  848.                 ORName [[p cp]],
  849.  
  850.  
  851.             ContentType [[i get_content_type (ad_list, parm)]],
  852.  
  853.             UAContentId [[p parm->ua_id]] OPTIONAL
  854.                         <<parm->ua_id != NULLCP>>,
  855.  
  856.             original %{
  857.                 b.eit = &parm->orig_encodedinfo;
  858.                 b.bp = NULL;
  859.             %} EncodedInformationTypes
  860.                          [[p &b]] OPTIONAL
  861.                                 <<parm->orig_encodedinfo.eit_types != 0>>,
  862.  
  863.             TraceInformation [[p &parm->trace]],
  864.  
  865.             PerMessageFlag [[p parm]]
  866.         DEFAULT {} << parm -> implicit_conversion_prohibited ||
  867.             parm -> alternate_recip_allowed >>,
  868.  
  869.             contentLength [0]
  870.                 IMPLICIT INTEGER [[i parm->msgsize]] OPTIONAL
  871.             <<parm->msgsize > 0>>,
  872.  
  873.             [1]
  874.                 IMPLICIT SEQUENCE OF PerDomainBilateralInfo
  875.                 OPTIONAL,
  876.  
  877.             [2]
  878.                 IMPLICIT SEQUENCE OF
  879.                 << ap = parm -> disclose_recips ? parm->Raddress : ad_list; 
  880.            ap != NULLADDR; ap=ap->ad_next>>
  881.                         RecipientInfo [[p ap]]
  882. }
  883.  
  884. END
  885.  
  886.  
  887.  
  888.  
  889. %{
  890.  
  891.  
  892. static int get_content_type (ad, qp)
  893. ADDR            *ad;
  894. Q_struct        *qp;
  895. {
  896.         char    *p;
  897.  
  898.         if (isstr(ad -> ad_content))
  899.                 p = ad -> ad_content;
  900.         else    p = qp -> cont_type;
  901.  
  902.         if (lexequ (p, cont_p2) != 0)
  903.                 adios (NULLCP, "Bad content type %s", p);
  904.  
  905.         return 2;
  906. }
  907.  
  908.  
  909.  
  910. static int pmf2int (parm)  /* --- PerMessageFlag Params -> integer --- */
  911. Q_struct        *parm;
  912. {
  913.  
  914.     aninteger = 0;
  915.  
  916.     switch (parm -> msgtype) {
  917.     case MT_PMPDU: 
  918.         /* --- *** --- 
  919.         only the conversionProhibited and alternateRecipientAllowed
  920.         flags affect the deliverability of the message as tested by 
  921.         Probe. - See X.411 page 164.
  922.         --- *** --- */
  923.         
  924.             if (parm -> implicit_conversion_prohibited) 
  925.                     aninteger |= (1 << 1);
  926.             if (parm -> alternate_recip_allowed) 
  927.                     aninteger |= (1 << 2);
  928.         break;
  929.  
  930.     default:
  931.             if (parm -> disclose_recips) 
  932.                     aninteger |= (1 << 0);
  933.             if (parm -> implicit_conversion_prohibited) 
  934.                     aninteger |= (1 << 1);
  935.             if (parm -> alternate_recip_allowed) 
  936.                     aninteger |= (1 << 2);
  937.             if (parm -> content_return_request) 
  938.                     aninteger |= (1 << 3);
  939.         break;
  940.     }
  941.  
  942.         return aninteger;
  943. }
  944.  
  945.  
  946.  
  947. /* --- *** ---  
  948. This routine is necessary because sometimes the supplementary
  949. information field has return characeters which is not valid X.409
  950. --- *** --- */
  951.  
  952. static void convert2printablestring (ptr)
  953. char    *ptr;
  954. {
  955.     char    *cp;
  956.  
  957.     for (cp = ptr; isstr(cp); cp++)
  958.         switch (*cp) {
  959.         case '\n':
  960.         case '\t':
  961.             *cp = ' ';
  962.             break;
  963.         default:
  964.             break;
  965.         }
  966. }
  967.  
  968.  
  969.  
  970.  
  971. static void compress_trace (tpp)
  972. Trace        **tpp;
  973. {
  974.  
  975.     switch (trace_type) {
  976.     case RTSP_TRACE_ADMD:
  977.         compress_trace_admd_style (tpp);
  978.         break;
  979.     case RTSP_TRACE_LOCALINT:
  980.         compress_trace_localinternal_style (tpp);
  981.         break;
  982.     }
  983.     
  984.     return;
  985. }
  986.  
  987.  
  988.  
  989.  
  990. static void compress_trace_admd_style (tpp)
  991. Trace        **tpp;
  992. {
  993.     Trace    *tlast,
  994.         *tlast_butone = (Trace *)0,
  995.         *tp = *tpp; 
  996.  
  997.  
  998.     /* --- *** --- 
  999.     Keep the first and last. Get rid of intermediate. If the ADMD is 
  1000.     the same in the first and last trace, then keep only the first. 
  1001.     --- *** --- */
  1002.  
  1003.     for (tlast = tp; tlast && tlast -> trace_next;
  1004.                 tlast = tlast -> trace_next) {
  1005.                         tlast_butone = tlast;
  1006.                         continue;
  1007.         }
  1008.  
  1009.         if (tlast != tp && same_trace (tlast, tp)) {
  1010.                 /* -- keep only the first trace -- */
  1011.                 trace_free (tp -> trace_next);
  1012.                 tp -> trace_next = (Trace *)0;
  1013.         }
  1014.         else if (tlast != tp) {
  1015.                 /* -- keep first and last, remove intermediates -- */
  1016.                 tlast_butone -> trace_next = (Trace *)0;
  1017.                 trace_free (tp -> trace_next);
  1018.                 tp -> trace_next = tlast;
  1019.         }
  1020.  
  1021.     *tpp = tp;
  1022.     return;
  1023. }
  1024.  
  1025.  
  1026.  
  1027.  
  1028. static void compress_trace_localinternal_style (tpp)
  1029. Trace        **tpp;
  1030. {
  1031.     Trace    *tnew,    
  1032.         *tprev = (Trace *)0,
  1033.         *tptr,
  1034.         *tp = *tpp;
  1035.  
  1036.     /* -- *** -- 
  1037.     Throw away ALL trace that is not of the local PRMD 
  1038.     -- *** -- */
  1039.  
  1040.     tnew = trace_new();
  1041.  
  1042.     for (tptr = tp; tptr; tptr = tptr -> trace_next) {
  1043.         if (!same_trace (tnew, tptr))
  1044.             break;
  1045.         tprev = tptr;
  1046.     }
  1047.     
  1048.     if (tprev)
  1049.         tprev -> trace_next = (Trace *)0;
  1050.  
  1051.     trace_free (tptr);
  1052.     trace_free (tnew);
  1053.  
  1054.     *tpp = tp;
  1055.  
  1056.     return;
  1057. }
  1058.  
  1059.  
  1060.  
  1061.  
  1062. static int same_trace (tp1, tp2)
  1063. Trace    *tp1;
  1064. Trace    *tp2;
  1065. {
  1066.     GlobalDomId    *d1 = &tp1 -> trace_DomId;
  1067.     GlobalDomId    *d2 = &tp2 -> trace_DomId;
  1068.  
  1069.  
  1070.     if (d1 -> global_Country && d2 -> global_Country &&
  1071.         lexequ (d1 -> global_Country, d2 -> global_Country) == 0 &&
  1072.         d1 -> global_Admin && d2 -> global_Admin &&
  1073.         lexequ (d1 -> global_Admin, d2 -> global_Admin) == 0) {
  1074.  
  1075.             if (d1 -> global_Private == NULL &&
  1076.                     d2 -> global_Private == NULL)
  1077.                     return TRUE;
  1078.  
  1079.             if (d1 -> global_Private && d2 -> global_Private &&
  1080.                     lexequ (d1 -> global_Private,
  1081.                     d2 -> global_Private) == 0)
  1082.                     return TRUE;
  1083.     }
  1084.  
  1085.     return FALSE;
  1086. }
  1087.  
  1088.  
  1089.  
  1090.  
  1091. static int or_print_struct (or, indent)
  1092. OR_ptr  or;
  1093. int    indent;
  1094. {
  1095.     char    buf[BUFSIZ];
  1096.     int    i;
  1097.  
  1098. #ifdef  DEBUG
  1099.     if (or == NULLOR) return;
  1100.  
  1101.     for (i = 0; i < indent; i++)
  1102.         buf[i] = ' ';
  1103.     buf[i] = '\0';
  1104.  
  1105.     PP_TRACE (("%s%s = %s", buf, or_type2name(or->or_type), or->or_value));
  1106.  
  1107.     or_print_struct (or -> or_next, indent + 3);
  1108. #endif  DEBUG
  1109. }
  1110.  
  1111.  
  1112. %}
  1113.